home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpuzzles.3 / xpuzzles / xpuzzles-5.3.1 / xhexagons / xhexagons.c < prev    next >
C/C++ Source or Header  |  1996-02-05  |  8KB  |  317 lines
  1. /*
  2. # X-BASED HEXAGONS
  3. #
  4. #  xhexagons.c
  5. #
  6. ###
  7. #
  8. #  Copyright (c) 1994 - 96    David Albert Bagley, bagleyd@hertz.njit.edu
  9. #
  10. #                   All Rights Reserved
  11. #
  12. #  Permission to use, copy, modify, and distribute this software and
  13. #  its documentation for any purpose and without fee is hereby granted,
  14. #  provided that the above copyright notice appear in all copies and
  15. #  that both that copyright notice and this permission notice appear in
  16. #  supporting documentation, and that the name of the author not be
  17. #  used in advertising or publicity pertaining to distribution of the
  18. #  software without specific, written prior permission.
  19. #
  20. #  This program is distributed in the hope that it will be "playable",
  21. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  23. #
  24. */
  25.  
  26. /*
  27.   Version 4: 94/06/07 Xt
  28.   Version 3: 93/04/01 Motif
  29.   Version 2: 92/01/06 XView
  30.   Version 1: 91/09/05 SunView
  31. */
  32.  
  33. #include <stdlib.h>
  34. #include <stdio.h>
  35. #ifdef VMS
  36. #include <unixlib.h>
  37. #define getlogin cuserid
  38. #else
  39. #ifndef apollo
  40. #include <unistd.h>
  41. #endif
  42. #endif
  43. #include <X11/Intrinsic.h>
  44. #include <X11/StringDefs.h>
  45. #include <X11/Shell.h>
  46. #include <X11/cursorfont.h>
  47. #include "Hexagons.h"
  48. #include "hexagons.xbm"
  49.  
  50. #ifndef SCOREFILE
  51. #define SCOREFILE "/usr/games/lib/hexagons.scores"
  52. #endif
  53.  
  54. /* The following are in HexagonsP.h also */
  55. #define MINHEXAGONS 1
  56. #define NOCORN 0
  57. #define CORNERS 1
  58. #define MAXORIENT 2
  59.  
  60. #define MAXHEXAGONS 12
  61. #define MAXRECORD 32767
  62. #define MAXPROGNAME 80
  63. #define MAXNAME 256
  64.  
  65. static void Initialize();
  66. static void CallbackHexagons();
  67.  
  68. static void PrintRecord();
  69. static int HandleSolved();
  70. static void PrintState();
  71. static void ReadRecords();
  72. static void WriteRecords();
  73.  
  74. static Arg arg[1];
  75. static int hexagonsRecord[MAXORIENT][MAXHEXAGONS - MINHEXAGONS + 1],
  76.   movesDsp = 0;
  77. static char progDsp[64] = "xhexagons";
  78. static char recordDsp[16] = "INF";
  79. static char messageDsp[128] = "Welcome";
  80. static char titleDsp[256] = "";
  81.  
  82. static void Usage()
  83. {
  84.   (void) fprintf(stderr, "usage: xhexagons\n");
  85.   (void) fprintf(stderr,
  86.     "\t[-geometry [{width}][x{height}][{+-}{xoff}[{+-}{yoff}]]]\n");
  87.   (void) fprintf(stderr,
  88.     "\t[-display [{host}]:[{vs}]][-fg {color}] [-bg {color}]\n");
  89.   (void) fprintf(stderr,
  90.     "\t[-tile {color}] [-{border|bd} {color}] [-size {int}] [-[no]corners]\n");
  91.   exit(1);
  92. }
  93.  
  94. static XrmOptionDescRec options[] = {
  95.   {"-fg",        "*hexagons.Foreground",    XrmoptionSepArg,    NULL},
  96.   {"-bg",        "*Background",        XrmoptionSepArg,    NULL},
  97.   {"-foreground",    "*hexagons.Foreground",    XrmoptionSepArg,    NULL},
  98.   {"-background",    "*Background",        XrmoptionSepArg,    NULL},
  99.   {"-tile",        "*hexagons.tileColor",    XrmoptionSepArg,    NULL},
  100.   {"-border",        "*hexagons.tileBorder",    XrmoptionSepArg,    NULL},
  101.   {"-bd",        "*hexagons.tileBorder",    XrmoptionSepArg,    NULL},
  102.   {"-size",        "*hexagons.size",    XrmoptionSepArg,    NULL},
  103.   {"-corners",        "*hexagons.corners",    XrmoptionNoArg,        "TRUE"},
  104.   {"-nocorners",    "*hexagons.corners",    XrmoptionNoArg,        "FALSE"}
  105. };
  106.  
  107. int main(argc, argv)
  108.   int argc;
  109.   char *argv[];
  110. {
  111.   Widget toplevel, hexagons; 
  112.  
  113.   toplevel = XtInitialize(argv[0], "Hexagons",
  114.     options, XtNumber(options), &argc, argv);
  115.   if (argc != 1)
  116.     Usage();
  117.  
  118.   XtSetArg(arg[0], XtNiconPixmap,
  119.     XCreateBitmapFromData(XtDisplay(toplevel),
  120.       RootWindowOfScreen(XtScreen(toplevel)),
  121.       (char *) hexagons_bits, hexagons_width, hexagons_height));
  122.   XtSetValues(toplevel, arg, 1);
  123.   hexagons = XtCreateManagedWidget("hexagons", hexagonsWidgetClass, toplevel,
  124.     NULL, 0);
  125.   XtAddCallback(hexagons, XtNselectCallback, CallbackHexagons, NULL);
  126.   Initialize(hexagons);
  127.   XtRealizeWidget(toplevel);
  128.   XGrabButton(XtDisplay(hexagons), AnyButton, AnyModifier, XtWindow(hexagons),
  129.     TRUE, ButtonPressMask | ButtonMotionMask | ButtonReleaseMask,
  130.     GrabModeAsync, GrabModeAsync, XtWindow(hexagons),
  131.     XCreateFontCursor(XtDisplay(hexagons), XC_crosshair));
  132.   XtMainLoop();
  133.  
  134. #ifdef VMS
  135.   return 1;
  136. #else
  137.   return 0;
  138. #endif
  139. }
  140.  
  141. static void Initialize(w)
  142.   Widget w;
  143. {
  144.   int size;
  145.   Boolean corners;
  146.  
  147.   XtVaSetValues(w,
  148.     XtNstart, FALSE,
  149.     NULL);
  150.   XtVaGetValues(w,
  151.     XtNsize, &size,
  152.     XtNcorners, &corners,
  153.     NULL);
  154.   ReadRecords();
  155.   PrintRecord(size, corners, recordDsp);
  156.   PrintState(XtParent(w), progDsp, size, movesDsp,
  157.     recordDsp, messageDsp);
  158. }
  159.  
  160. static void CallbackHexagons(w, clientData, callData)
  161.   Widget w;
  162.   caddr_t clientData;
  163.   hexagonsCallbackStruct *callData;
  164. {
  165.   int size;
  166.   Boolean corners;
  167.  
  168.   XtVaGetValues(w,
  169.     XtNsize, &size,
  170.     XtNcorners, &corners,
  171.     NULL);
  172.   (void) strcpy(messageDsp, "");
  173.   switch (callData->reason) {
  174.     case HEXAGONS_RESTORE:
  175.     case HEXAGONS_RESET:
  176.       movesDsp = 0;
  177.       break;
  178.     case HEXAGONS_BLOCKED:
  179.       (void) strcpy(messageDsp, "Blocked");
  180.       break;
  181.     case HEXAGONS_SPACE:
  182.       /*(void) strcpy(messageDsp, "Spaces can't move");*/  /* Too annoying */
  183.       break;
  184.     case HEXAGONS_IGNORE:
  185.       (void) strcpy(messageDsp, "Randomize to start");
  186.       break;
  187.     case HEXAGONS_MOVED:
  188.       movesDsp++;
  189.       XtSetArg(arg[0], XtNstart, TRUE);
  190.       XtSetValues(w, arg, 1);
  191.       break;
  192.     case HEXAGONS_SOLVED:
  193.       if (HandleSolved(movesDsp, size, corners))
  194.         (void) sprintf(messageDsp, "Congratulations %s!!", getlogin());
  195.       else
  196.         (void) strcpy(messageDsp, "Solved!");
  197.       XtSetArg(arg[0], XtNstart, FALSE);
  198.       XtSetValues(w, arg, 1);
  199.       break;
  200.     case HEXAGONS_RANDOMIZE:
  201.       movesDsp = 0;
  202.       XtSetArg(arg[0], XtNstart, FALSE);
  203.       XtSetValues(w, arg, 1);
  204.       break; 
  205.     case HEXAGONS_DEC:
  206.       movesDsp = 0;
  207.       size--;
  208.       PrintRecord(size, corners, recordDsp);
  209.       XtSetArg(arg[0], XtNsize, size);
  210.       XtSetValues(w, arg, 1);
  211.       break;
  212.     case HEXAGONS_INC:
  213.       movesDsp = 0;
  214.       size++;
  215.       PrintRecord(size, corners, recordDsp);
  216.       XtSetArg(arg[0], XtNsize, size);
  217.       XtSetValues(w, arg, 1);
  218.       break;
  219.     case HEXAGONS_CORNERS:
  220.       movesDsp = 0;
  221.       corners = !corners;
  222.       PrintRecord(size, corners, recordDsp);
  223.       XtSetArg(arg[0], XtNcorners, corners);
  224.       XtSetValues(w, arg, 1);
  225.       break;
  226.     case HEXAGONS_COMPUTED:
  227.       XtSetArg(arg[0], XtNstart, FALSE);
  228.       XtSetValues(w, arg, 1);
  229.       break;
  230.     case HEXAGONS_UNDO:
  231.       movesDsp--;
  232.       XtSetArg(arg[0], XtNstart, TRUE);
  233.       XtSetValues(w, arg, 1);
  234.       break;
  235.   }
  236.   PrintState(XtParent(w), progDsp, size, movesDsp,
  237.     recordDsp, messageDsp);
  238. }
  239.  
  240. static void PrintRecord(size, corners, record)
  241.   int size;
  242.   Boolean corners;
  243.   char *record;
  244. {
  245.   int i = (corners) ? 1 : 0, j = size - MINHEXAGONS;
  246.  
  247.   if (size > MAXHEXAGONS)
  248.     (void) strcpy(record, "NOT RECORDED");
  249.   else if (hexagonsRecord[i][j] >= MAXRECORD)
  250.     (void) strcpy(record, "NEVER");
  251.   else
  252.     (void) sprintf(record, "%d", hexagonsRecord[i][j]);
  253. }
  254.  
  255. static int HandleSolved(counter, size, corners)
  256.   int counter, size;
  257.   Boolean corners;
  258. {
  259.   int i = (corners) ? 1 : 0, j = size - MINHEXAGONS;
  260.  
  261.   if (size <= MAXHEXAGONS && counter < hexagonsRecord[i][j]) {
  262.     hexagonsRecord[i][j] = counter;
  263.     WriteRecords();
  264.     (void) sprintf(recordDsp, "%d", counter);
  265.     return TRUE;
  266.   }
  267.   return FALSE;
  268. }
  269.  
  270. static void PrintState(w, prog, size, moves, record, message)
  271.   Widget w;
  272.   char *prog, *record, *message;
  273.   int size, moves;
  274. {
  275.   (void) sprintf(titleDsp, "%s: %d@ (%d/%s) - %s",
  276.            prog, size, moves, record, message);
  277.   XtSetArg(arg[0], XtNtitle, titleDsp);
  278.   XtSetValues(w, arg, 1);
  279. }
  280.  
  281. static void ReadRecords()
  282. {
  283.   FILE *fp;
  284.   int i, j, n;
  285.  
  286.   for (i = 0; i < MAXORIENT; i++)
  287.     for (j = 0; j < MAXHEXAGONS - MINHEXAGONS + 1; j++)
  288.       hexagonsRecord[i][j] = MAXRECORD;
  289.   if ((fp = fopen(SCOREFILE, "r")) == NULL)
  290.     (void) sprintf(messageDsp, "Can not open %s, taking defaults.", SCOREFILE);
  291.   else {
  292.     for (i = 0; i < MAXORIENT; i++)
  293.       for (j = 0; j < MAXHEXAGONS - MINHEXAGONS + 1; j++) {
  294.         (void) fscanf(fp, "%d", &n);
  295.         hexagonsRecord[i][j] = n;
  296.     }
  297.     (void) fclose(fp);
  298.   }
  299. }
  300.  
  301. static void WriteRecords()
  302. {
  303.   FILE *fp;
  304.   int i, j;
  305.  
  306.   if ((fp = fopen(SCOREFILE, "w")) == NULL)
  307.     (void) sprintf(messageDsp, "Can not write to %s.", SCOREFILE);
  308.   else {
  309.     for (i = 0; i < MAXORIENT; i++) {
  310.       for (j = 0; j < MAXHEXAGONS - MINHEXAGONS + 1; j++)
  311.         (void) fprintf(fp, "%d ", hexagonsRecord[i][j]);
  312.       (void) fprintf(fp, "\n");
  313.     }
  314.     (void) fclose(fp);
  315.   }
  316. }
  317.